SpringBoot 整合单元测试

整合单元测试

SpringBoot 对单元测试进行了整合

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

注意：junit-vintage-engine 是一个为了兼容旧版的单元测试工具（在 JUnit Platform 上运行 JUnit 3 和 JUnit 4 测试的测试引擎），为了平滑过渡到 Junit 所以 SpringBoot 集成了这个 “Junit-老式-引擎” 而现在的项目基本全部使用 Junit5 所以需要手动排除掉这个东西

点开 spring-boot-starter-test 可以看到这玩意

使用例

只需要加入 @SpringBootTest 就可以标明这个是 Spring 的单元测试了，所以可以自动注入

@SpringBootTest
class StudyApplicationTests {

    @Autowired
    private HelloController helloController;

    @Test
    void contextLoads() {
        helloController.hello();
    }

}

整合 MockMvc进行单元测试

依赖的环境依旧是上面的 test 框架

有时候需要对Controller层（API）做测试，这时候就得用到 MockMvc了，可以不必启动工程就能测试这些接口。MockMvc 实现了对 Http 请求的模拟，能够直接使用网络的形式，转换到 Controller 的调用，这样可以使得测试速度快、不依赖网络环境，而且提供了一套验证的工具，这样可以使得请求的验证统一而且很方便。

为什么使用 Mock对象

使用模拟对象，可以模拟复杂的、真实的对象行为。如果在单元测试中无法使用真实对象，可采用模拟对象进行替代。

在以下情况可以采用模拟对象来替代真实对象：

真实对象的行为是不确定的（例如，当前的时间或温度）；
真实对象很难搭建起来；
真实对象的行为很难触发（例如，网络错误）；
真实对象速度很慢（例如，一个完整的数据库，在测试之前可能需要初始化）；
真实的对象是用户界面，或包括用户界面在内；
真实的对象使用了回调机制；
真实对象可能还不存在；
真实对象可能包含不能用作测试（而不是为实际工作）的信息和方法。

使用 Mockito 一般分三个步骤： 1、模拟测试类所需的外部依赖； 2、执行测试代码； 3、判断执行结果是否达到预期；

构建 MockMvc

MockMvc 有两个实现：

1、StandaloneMockMvcBuilder：指定 WebApplicationContext，它将会从该上下文获取相应的控制器并得到相应的 MockMvc

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserControllerTest  {
    @Autowired
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;

    @Before
    public void setUp() throws Exception {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
}

2、DefaultMockMvcBuilder：通过参数指定一组控制器，这样就不需要从上下文获取了

@RunWith(SpringRunner.class)
public class UserControllerTest  {
    private MockMvc mockMvc;

    @Before
    public void setUp() throws Exception {
        mockMvc = MockMvcBuilders.standaloneSetup(new UserController()).build();
    }
}

但是一般都不使用上面两种方式，SpringBootTest 提供了一个 @AutoConfigureMockMvc 注解可以自动构建一个 MockMvc 对象

// 这个 WebEnvironment 可以用来设置测试的 Web 环境，默认是 Mock
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc // 这个注解可以用来自动注入 mockMvc
class HelloResourceTest {

    @Autowired
    private WebApplicationContext webApplicationContext;
    @Autowired
    private MockMvc mockMvc;
...

使用它的好处是它内部做了好了默认配置，例如添加过滤器的那个问题（看下面 Filter 那一节）

基本使用示例

先随便写几个 Controller层的 API

@Slf4j
@RestController
@RequestMapping("/test")
public class HelloController {

    @GetMapping("/hello")
    public ResponseEntity<String> sayHello() {
        return ResponseEntity.ok("hello java");
    }

    @PostMapping("/register")
    public ResponseEntity<Student> registerStudent(@RequestBody Student student) {
        log.debug(student.toString());
        return ResponseEntity.ok(student);
    }
}

这个 Entity 如下

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private String name;
    private Integer age;
}

Spring 提供了 MockMVC 用于支持 RESTful 风格的 Spring MVC 测试，使用 MockMvcBuilder 来构造MockMvc 实例。

单元测试类如下

@SpringBootTest
class HelloControllerTest {

    @Autowired
    private WebApplicationContext webApplicationContext;
    private MockMvc mockMvc;


    @BeforeEach
    void setUp() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
    }

    /*
     * 1、mockMvc.perform执行一个请求。
     * 2、MockMvcRequestBuilders.get("XXX")构造一个请求。
     * 3、ResultActions.param添加请求传值
     * 4、ResultActions.accept(MediaType.TEXT_HTML_VALUE))设置返回类型
     * 5、ResultActions.andExpect添加执行完成后的断言。
     * 6、ResultActions.andDo添加一个结果处理器，表示要对结果做点什么事情
     *   比如此处使用MockMvcResultHandlers.print()输出整个响应结果信息。
     * 7、ResultActions.andReturn表示执行完成后返回相应的结果。
     */
    @Test
    void sayHello() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders
                .get("/test/hello")
                // 设置返回值类型为utf-8，否则默认为ISO-8859-1(新版的 APPLICATION_JSON_UTF8_VALUE 已经弃用了，直接使用 APPLICATION_JSON_VALUE)
                .accept(MediaType.APPLICATION_JSON_VALUE)
                .param("name", "Tom").param("age", "18"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Hello Java"))
                .andDo(MockMvcResultHandlers.print());
    }

    @Test
    void registerStudent() throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(new Student("张三", 18));

        // 注意别忘了加上这个 .contentType("application/json;charset=UTF-8") 它表示请求类型
        // .accept(MediaType.APPLICATION_JSON_VALUE) 表示响应类型
        mockMvc.perform(MockMvcRequestBuilders
                .post("/test/register")
                // 设置返回值类型为utf-8，否则默认为ISO-8859-1(新版的 APPLICATION_JSON_UTF8_VALUE 已经弃用了，直接使用 APPLICATION_JSON_VALUE)
                .accept(MediaType.APPLICATION_JSON_VALUE)
                .contentType("application/json;charset=UTF-8")
                .content(json.getBytes(StandardCharsets.UTF_8)))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print());
    }
}

注意事项：如果使用 DefaultMockMvcBuilder 进行 MockMvc 实例化时需在 SpringBoot 启动类上添加组件扫描的 package 的指定，否则会出现404。如：

@ComponentScan(basePackages = "com.alsritter")
// 或者直接使用
@SpringBootApplication // 它内涵了上面那个注解

测试普通控制器

mockMvc.perform(get("/user/{id}", 1)) //执行请求  
            .andExpect(model().attributeExists("user")) //验证存储模型数据  
            .andExpect(view().name("user/view")) //验证viewName  
            .andExpect(forwardedUrl("/WEB-INF/jsp/user/view.jsp"))//验证视图渲染时forward到的jsp  
            .andExpect(status().isOk())//验证状态码  
            .andDo(print()); //输出MvcResult到控制台

得到 MvcResult 自定义验证

MvcResult result = mockMvc.perform(get("/user/{id}", 1))//执行请求  
        .andReturn(); //返回MvcResult  

Assert.assertNotNull(result.getModelAndView().getModel().get("user")); //自定义断言

验证请求参数绑定到模型数据及 Flash属性

//执行传递参数的POST请求(也可以post("/user?name=zhang"))  
mockMvc.perform(post("/user").param("name", "zhang")) 
            .andExpect(handler().handlerType(UserController.class)) //验证执行的控制器类型  
            .andExpect(handler().methodName("create")) //验证执行的控制器方法名  
            .andExpect(model().hasNoErrors()) //验证页面没有错误  
            .andExpect(flash().attributeExists("success")) //验证存在flash属性  
            .andExpect(view().name("redirect:/user")); //验证视图

文件上传

byte[] bytes = new byte[] {1, 2};  
mockMvc.perform(fileUpload("/user/{id}/icon", 1L).file("icon", bytes)) //执行文件上传  
        .andExpect(model().attribute("icon", bytes)) //验证属性相等性  
        .andExpect(view().name("success")); //验证视图

JSON请求/响应验证

String requestBody = "{\"id\":1, \"name\":\"zhang\"}"; 

mockMvc.perform(post("/user")  
            .contentType(MediaType.APPLICATION_JSON).content(requestBody)  
            .accept(MediaType.APPLICATION_JSON)) //执行请求  
            .andExpect(content().contentType(MediaType.APPLICATION_JSON)) //验证响应contentType  
            .andExpect(jsonPath("$.id").value(1)); //使用Json path验证JSON 请参考http://goessner.net/articles/JsonPath/  
String errorBody = "{id:1, name:zhang}";

MvcResult result = mockMvc.perform(post("/user")  
            .contentType(MediaType.APPLICATION_JSON).content(errorBody)  
            .accept(MediaType.APPLICATION_JSON)) //执行请求  
            .andExpect(status().isBadRequest()) //400错误请求  
            .andReturn();  

Assert.assertTrue(HttpMessageNotReadableException.class.isAssignableFrom(result.getResolvedException().getClass()));//错误的请求内容体

异步测试

//Callable  
MvcResult result = mockMvc.perform(get("/user/async1?id=1&name=zhang")) //执行请求  
            .andExpect(request().asyncStarted())  
            .andExpect(request().asyncResult(CoreMatchers.instanceOf(User.class))) //默认会等10秒超时  
            .andReturn();

mockMvc.perform(asyncDispatch(result))  
            .andExpect(status().isOk())  
            .andExpect(content().contentType(MediaType.APPLICATION_JSON))  
            .andExpect(jsonPath("$.id").value(1));

全局配置

mockMvc = webAppContextSetup(wac)  
            .defaultRequest(get("/user/1").requestAttr("default", true)) //默认请求 如果其是Mergeable类型的，会自动合并的哦mockMvc.perform中的RequestBuilder  
            .alwaysDo(print())  //默认每次执行请求后都做的动作  
            .alwaysExpect(request().attribute("default", true)) //默认每次执行后进行验证的断言  
            .build();  

mockMvc.perform(get("/user/1"))  
            .andExpect(model().attributeExists("user"));

添加过滤器的问题

上面那样手动构建的模拟对象默认是不走过滤器的

可以使用 @AutoConfigureMockMvc 注解自动构建这个 mockMvc

// 这个 WebEnvironment 可以用来设置测试的 Web 环境，默认是 Mock
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@AutoConfigureMockMvc // 这个注解可以用来自动注入 mockMvc
class HelloResourceTest {

    @Autowired
    private WebApplicationContext webApplicationContext;
    @Autowired
    private MockMvc mockMvc;
...

这个 @AutoConfigureMockMvc 注解通过 SpringBootMockMvcBuilderCustomizer 来构建，且它内部默认会注入过滤器，如下它的内部方法

private void addFilters(ConfigurableMockMvcBuilder<?> builder) {
    FilterRegistrationBeans registrations = new FilterRegistrationBeans(this.context);
    registrations.stream().map(AbstractFilterRegistrationBean.class::cast)
            .filter(AbstractFilterRegistrationBean<?>::isEnabled)
            .forEach((registration) -> addFilter(builder, registration));
}

整合单元测试​

整合 MockMvc进行单元测试​

为什么使用 Mock对象​

构建 MockMvc​

基本使用示例​

相关API​

测试普通控制器​

得到 MvcResult 自定义验证​

验证请求参数绑定到模型数据及 Flash属性​

文件上传​

JSON请求/响应验证​

异步测试​

全局配置​

添加过滤器的问题​